{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "# भाग 8 बीआईएस - Protocols (प्रोटोकॉल) का परिचय\n",
    "\n",
    "### प्रसंग\n",
    "\n",
    "अब जब हम प्‍लान के माध्यम से आ गए हैं, तो हम प्रोटोकॉल नामक एक नई वस्तु पेश करेंगे। एक प्रोटोकॉल प्‍लान के अनुक्रम का समन्वय करता है, उन्हें दूर के श्रमिकों पर तैनात करता है और उन्हें एक पास में चलाता है।\n",
    "\n",
    "यह एक उच्च स्तरीय वस्तु है जिसमें एक जटिल संगणना का तर्क समाहित है कई श्रमिकों में वितरित किया गया। प्रोटोकॉल की मुख्य विशेषता है\n",
    "श्रमिकों के बीच वापस भेजने / खोजे जाने / पाने की क्षमता और अंत में चिन्हित श्रमिकों को तैनात किया गया। तो एक उपयोगकर्ता एक प्रोटोकॉल डिजाइन कर सकता है, उसे क्लाउड वर्कर  में अपलोड कर सकता है, और कोई भी अन्य कर्मी इसकी खोज करने में सक्षम होगा, इसे डाउनलोड कर सकता है, और श्रमिकों जिस पर यह जुड़ा हुआ है उन पर यह गणना कार्यक्रम लागू कर सकता है।\n",
    "\n",
    "आइए देखें कि इसका उपयोग कैसे करें!\n",
    "\n",
    "लेखक:\n",
    "- Théo Ryffel - Twitter [@theoryffel](https://twitter.com/theoryffel) - Github: [@LaRiffle](https://github.com/LaRiffle)\n",
    "\n",
    "nbTranslate का उपयोग करके अनुवादित\n",
    "\n",
    "संपादक:\n",
    "\n",
    "- Urvashi Raheja - Github: [@raheja](https://github.com/raheja)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "### 1. बनाएं और तैनात करें"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "प्रोटोकॉल जोड़े `(worker, plan)` की एक सूची प्रदान करके बनाए गए हैं। `worker` या तो एक वास्तविक कार्यकर्ता हो सकता है या कार्यकर्ता आईडी या एक स्ट्रिंग एक काल्पनिक कार्यकर्ता का प्रतिनिधित्व करने के लिए। यह अंतिम मामला, निर्माण में इस्तेमाल किया जा सकता है, यह निर्दिष्ट करने के लिए कि दो प्‍लान तैनाती पर एक ही कार्यकर्ता द्वारा स्वामित्व (या स्वामित्व में नहीं) होने चाहिए। `plan` या तो एक प्‍लान हो या एक PointerPlan हो।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch as th\n",
    "import syft as sy\n",
    "hook = sy.TorchHook(th)\n",
    "\n",
    "# IMPORTANT: Local worker should not be a client worker\n",
    "hook.local_worker.is_client_worker = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "आइए 3 प्‍लान को परिभाषित करें और उन्हें एक प्रोटोकॉल में भेज दे। वे सभी एक क्रमशः वृद्धि ऑपरेशन करते हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@sy.func2plan(args_shape=[(1,)])\n",
    "def inc1(x):\n",
    "    return x + 1\n",
    "\n",
    "@sy.func2plan(args_shape=[(1,)])\n",
    "def inc2(x):\n",
    "    return x + 1\n",
    "\n",
    "@sy.func2plan(args_shape=[(1,)])\n",
    "def inc3(x):\n",
    "    return x + 1\n",
    "\n",
    "protocol = sy.Protocol([(\"worker1\", inc1), (\"worker2\", inc2), (\"worker3\", inc3)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "अब हमें श्रमिकों को प्रोटोकॉल बाँधने की आवश्यकता है, जिसे `.deploy (*workers)` कहकर किया जाता है। चलो कुछ कार्यकर्ता बनाते हैं।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob = sy.VirtualWorker(hook, id=\"bob\")\n",
    "alice = sy.VirtualWorker(hook, id=\"alice\")\n",
    "charlie = sy.VirtualWorker(hook, id=\"charlie\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "workers = alice, bob, charlie\n",
    "\n",
    "protocol.deploy(*workers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "आप देख सकते हैं कि प्‍लान पहले ही उपयुक्त श्रमिकों को भेज दी गई हैं: इसे तैनात किया गया है!\n",
    "\n",
    "यह 2 चरणों में किया गया है: पहला, हम निर्माण में प्रदान किए गए काल्पनिक श्रमिकों का नक्शा बनाते हैं\n",
    "(नाम स्ट्रिंग्स द्वारा) प्रदान किए गए श्रमिकों के लिए, और दूसरा, हम संबंधित को उनमें से प्रत्येक के लिए प्‍लान भेजते हैं। "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "### 2. एक प्रोटोकॉल चलाएँ\n",
    "\n",
    "एक प्रोटोकॉल चलाने का मतलब है कि सभी प्‍लान को क्रमिक रूप से निष्पादित करना। ऐसा करने के लिए, आप कुछ इनपुट डेटा प्रदान करते हैं जो पहले प्‍लान स्थान पर भेजा जाता है। यह प्रथम प्‍लान को रन और उसके आउटपुट को दूसरी प्‍लान स्थान पर ले जाया जाता है, और इसी तरह दोहराया जाता है। अंतिम\n",
    "सभी प्‍लान के चलने के बाद परिणाम लौटाया जाता है, और यह अंतिम प्‍लान स्थान के पॉइंटर से बना होता है।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = th.tensor([1.0])\n",
    "ptr = protocol.run(x)\n",
    "ptr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ptr.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "1.0 इनपुट 3 प्‍लान के माध्यम से है और इसलिए 3 बार वृद्धि की गई है, यही कारण है कि अब यह 4.0 के बराबर है!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "वास्तव में, आप डेटा पर कुछ पॉइंटर से **एक प्रोटोकॉल दूरस्थ रूप** में चला सकते हैं:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "james = sy.VirtualWorker(hook, id=\"james\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "protocol.send(james)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = th.tensor([1.0]).send(james)\n",
    "ptr = protocol.run(x)\n",
    "ptr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "जैसा कि आप देखते हैं कि परिणाम जेमर्स के लिए एक सूचक है"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ptr = ptr.get()\n",
    "ptr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ptr = ptr.get()\n",
    "ptr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "### 3. एक प्रोटोकॉल के लिए खोजें\n",
    "\n",
    "वास्तविक सेटिंग्स में आप एक दूरस्थ प्रोटोकॉल डाउनलोड करना चाहते हैं, इसे अपने कार्यकर्ताओं पर तैनात कर सकते हैं और इसे आपके डेटा के साथ चला सकते हैं:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "आइए एक प्रोटोकॉल को शुरू करें **जिसे परिनियोजित नहीं किया गया है**, और इसे एक दूरस्थ कार्यकर्ता पर रखें"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "protocol = sy.Protocol([(\"worker1\", inc1), (\"worker2\", inc2), (\"worker3\", inc3)])\n",
    "protocol.tag('my_protocol')\n",
    "protocol.send(james)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "me = sy.hook.local_worker # get access to me as a local worker"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "अब हम प्रोटोकॉल खोजने के लिए एक खोज शुरू करते हैं"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "responses = me.request_search(['my_protocol'], location=james)\n",
    "responses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "आपके पास एक प्रोटोकॉल के लिए एक पॉइंटर तक पहुंच है"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ptr_protocol = responses[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "सामान्य सूचक की तरह आप इसे वापस पा सकते हैं:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "protocol_back = ptr_protocol.get()\n",
    "protocol_back"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "और हम कर सकते हैं जैसे हमने भागों 1 और 2 में किया था।"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "protocol_back.deploy(alice, bob, charlie)\n",
    "\n",
    "x = th.tensor([1.0])\n",
    "ptr = protocol_back.run(x)\n",
    "ptr.get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "अधिक वास्तविक दुनिया के उदाहरण प्रोटोकॉल के साथ आएंगे, लेकिन आप पहले से ही इस नई वस्तु द्वारा खोली गई सभी संभावनाओं को देख सकते हैं!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "hi"
   },
   "source": [
    "### GitHub पर स्टार PySyft\n",
    "\n",
    "हमारे समुदाय की मदद करने का सबसे आसान तरीका सिर्फ रिपॉजिटरी को अभिनीत करना है! यह हमारे द्वारा बनाए जा रहे कूल टूल्स के बारे में जागरूकता बढ़ाने में मदद करता है।\n",
    "\n",
    "- [स्टार पायसफ्ट](https://github.com/OpenMined/PySyft)\n",
    "\n",
    "### GitHub पर हमारे ट्यूटोरियल चुनना!\n",
    "\n",
    "हमने फेडरेटेड और प्राइवेसी-प्रिजर्विंग लर्निंग और उसकी संरचना की बेहतर समझ प्राप्त करने के लिए वास्तव में अच्छा ट्यूटोरियल बनाया है।\n",
    "\n",
    "- [PySyft ट्यूटोरियल्स को चेक करें](https://github.com/OpenMined/PySyft/tree/master/examples/tutorials)\n",
    "\n",
    "\n",
    "### हमारे Slack में शामिल हों!\n",
    "\n",
    "नवीनतम प्रगति पर अद्यतित रहने का सबसे अच्छा तरीका हमारे समुदाय में शामिल होना है!\n",
    "\n",
    "- [slack.openmined.org से जुड़ें](http://slack.openmined.org)\n",
    "\n",
    "### एक कोड परियोजना में शामिल हों!\n",
    "\n",
    "हमारे समुदाय में योगदान करने का सबसे अच्छा तरीका एक कोड योगदानकर्ता बनना है! यदि आप \"one off\" मिनी-प्रोजेक्ट्स शुरू करना चाहते हैं, तो आप PySyft GitHub जारी करने वाले पृष्ठ पर जा सकते हैं और `Good First Issue` के रूप में चिह्नित मुद्दों की खोज कर सकते हैं।\n",
    "\n",
    "- [Good First Issue Tickets](https://github.com/OpenMined/PySyft/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22)\n",
    "\n",
    "### दान करना\n",
    "\n",
    "यदि आपके पास हमारे कोडबेस में योगदान करने का समय नहीं है, लेकिन फिर भी समर्थन उधार देना चाहते हैं, तो आप हमारे ओपन कलेक्टिव में भी एक बैकर बन सकते हैं। सभी दान हमारी वेब होस्टिंग और अन्य सामुदायिक खर्च जैसे कि हैकाथॉन और मीटअप की ओर जाते हैं!\n",
    "\n",
    "- [OpenMined's Open कलेक्टिव पेज के माध्यम से दान करें](https://opencollective.com/openmined)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "nbTranslate": {
   "displayLangs": [
    "hi"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "hi",
   "useGoogleTranslate": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
